home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / GLUT-3.7 / PROGS / CONTRIB / AGVIEWER.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-12  |  12.9 KB  |  498 lines
  1. /*
  2.  * agviewer.c  (version 1.0)
  3.  *
  4.  * AGV: a glut viewer. Routines for viewing a 3d scene w/ glut
  5.  *
  6.  * See agv_example.c and agviewer.h comments within for more info.
  7.  *
  8.  * I welcome any feedback or improved versions!
  9.  *
  10.  * Philip Winston - 4/11/95
  11.  * pwinston@hmc.edu
  12.  * http://www.cs.hmc.edu/people/pwinston
  13.  */
  14.  
  15. #include <GL/glut.h>
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <math.h>
  19.  
  20. #include "agviewer.h"
  21.  
  22. /* Some <math.h> files do not define M_PI... */
  23. #ifndef M_PI
  24. #define M_PI 3.14159265358979323846
  25. #endif
  26.  
  27. /***************************************************************/
  28. /************************** SETTINGS ***************************/
  29. /***************************************************************/
  30.  
  31.    /* Initial polar movement settings */
  32. #define INIT_POLAR_AZ  0.0
  33. #define INIT_POLAR_EL 30.0
  34. #define INIT_DIST      8.0
  35. #define INIT_AZ_SPIN   0.5
  36. #define INIT_EL_SPIN   0.0
  37.  
  38.   /* Initial flying movement settings */
  39. #define INIT_EX        0.0
  40. #define INIT_EY       -2.0
  41. #define INIT_EZ       -2.0
  42. #define INIT_MOVE     0.01
  43. #define MINMOVE      0.001    
  44.  
  45.   /* Start in this mode */
  46. #define INIT_MODE   POLAR   
  47.  
  48.   /* Controls:  */
  49.  
  50.   /* map 0-9 to an EyeMove value when number key is hit in FLYING mode */
  51. #define SPEEDFUNCTION(x) ((x)*(x)*0.001)  
  52.  
  53.   /* Multiply EyeMove by (1+-MOVEFRACTION) when +/- hit in FLYING mode */
  54. #define MOVEFRACTION 0.25   
  55.  
  56.   /* What to multiply number of pixels mouse moved by to get rotation amount */
  57. #define EL_SENS   0.5
  58. #define AZ_SENS   0.5
  59.  
  60.   /* What to multiply number of pixels mouse moved by for movement amounts */
  61. #define DIST_SENS 0.01
  62. #define E_SENS    0.01
  63.  
  64.   /* Minimum spin to allow in polar (lower forced to zero) */
  65. #define MIN_AZSPIN 0.1
  66. #define MIN_ELSPIN 0.1
  67.  
  68.   /* Factors used in computing dAz and dEl (which determine AzSpin, ElSpin) */
  69. #define SLOW_DAZ 0.90
  70. #define SLOW_DEL 0.90
  71. #define PREV_DAZ 0.80
  72. #define PREV_DEL 0.80
  73. #define CUR_DAZ  0.20
  74. #define CUR_DEL  0.20
  75.  
  76. /***************************************************************/
  77. /************************** GLOBALS ****************************/
  78. /***************************************************************/
  79.  
  80. int     MoveMode = INIT_MODE;  /* FLYING or POLAR mode? */
  81.  
  82. GLfloat Ex = INIT_EX,             /* flying parameters */
  83.         Ey = INIT_EY,
  84.         Ez = INIT_EZ,
  85.         EyeMove = INIT_MOVE,     
  86.  
  87.         EyeDist = INIT_DIST,      /* polar params */
  88.         AzSpin  = INIT_AZ_SPIN,
  89.         ElSpin  = INIT_EL_SPIN,
  90.  
  91.         EyeAz = INIT_POLAR_AZ,    /* used by both */
  92.         EyeEl = INIT_POLAR_EL;
  93.  
  94. int agvMoving;    /* Currently moving?  */
  95.  
  96. int downx, downy,   /* for tracking mouse position */
  97.     lastx, lasty,
  98.     downb = -1;     /* and button status */
  99.                         
  100. GLfloat downDist, downEl, downAz, /* for saving state of things */
  101.         downEx, downEy, downEz,   /* when button is pressed */
  102.         downEyeMove;                
  103.  
  104. GLfloat dAz, dEl, lastAz, lastEl;  /* to calculate spinning w/ polar motion */
  105. int     AdjustingAzEl = 0;
  106.  
  107. int AllowIdle, RedisplayWindow; 
  108.    /* If AllowIdle is 1 it means AGV will install its own idle which
  109.     * will update the viewpoint as needed and send glutPostRedisplay() to the
  110.     * window RedisplayWindow which was set in agvInit().  AllowIdle of 0
  111.     * means AGV won't install an idle funciton, and something like
  112.     * "if (agvMoving) agvMove()" should exist at the end of the running
  113.     * idle function.
  114.     */
  115.  
  116. #define MAX(x,y) (((x) > (y)) ? (x) : (y))
  117. #define TORAD(x) ((M_PI/180.0)*(x))
  118. #define TODEG(x) ((180.0/M_PI)*(x))
  119.  
  120. /***************************************************************/
  121. /************************ PROTOTYPES ***************************/
  122. /***************************************************************/
  123.  
  124.   /*
  125.    * these are functions meant for internal use only
  126.    * the other prototypes are in agviewer.h
  127.    */
  128.  
  129. void PolarLookFrom(GLfloat dist, GLfloat elevation, GLfloat azimuth);
  130. void FlyLookFrom(GLfloat x, GLfloat y, GLfloat z, GLfloat az, GLfloat el);
  131. int  ConstrainEl(void);
  132. void MoveOn(int v);
  133. void SetMove(float newmove);
  134. static void normalize(GLfloat v[3]);
  135. static void ncrossprod(float v1[3], float v2[3], float cp[3]);
  136.  
  137.  
  138. /***************************************************************/
  139. /************************ agvInit ******************************/
  140. /***************************************************************/
  141.  
  142. void agvInit(int window)
  143. {
  144.   glutMouseFunc(agvHandleButton);
  145.   glutMotionFunc(agvHandleMotion);
  146.   glutKeyboardFunc(agvHandleKeys);
  147.   RedisplayWindow = glutGetWindow();
  148.   agvSetAllowIdle(window);
  149. }
  150.  
  151. /***************************************************************/
  152. /************************ VIEWPOINT STUFF **********************/
  153. /***************************************************************/
  154.  
  155.   /*
  156.    * viewing transformation modified from page 90 of red book
  157.    */
  158. void PolarLookFrom(GLfloat dist, GLfloat elevation, GLfloat azimuth)
  159. {
  160.   glTranslatef(0, 0, -dist);
  161.   glRotatef(elevation, 1, 0, 0);
  162.   glRotatef(azimuth, 0, 1, 0);
  163.  
  164. }
  165.  
  166.   /*
  167.    * I took the idea of tracking eye position in absolute
  168.    * coords and direction looking in Polar form from denis
  169.    */
  170. void FlyLookFrom(GLfloat x, GLfloat y, GLfloat z, GLfloat az, GLfloat el)
  171. {
  172.   float lookat[3], perp[3], up[3];
  173.  
  174.   lookat[0] = sin(TORAD(az))*cos(TORAD(el));
  175.   lookat[1] = sin(TORAD(el));
  176.   lookat[2] = -cos(TORAD(az))*cos(TORAD(el));
  177.   normalize(lookat);
  178.   perp[0] = lookat[2];
  179.   perp[1] = 0;
  180.   perp[2] = -lookat[0];
  181.   normalize(perp);
  182.   ncrossprod(lookat, perp, up);
  183.   gluLookAt(x, y, z,
  184.             x+lookat[0], y+lookat[1], z+lookat[2],
  185.             up[0], up[1], up[2]);
  186. }
  187.  
  188.   /*
  189.    * Call viewing transformation based on movement mode
  190.    */
  191. void agvViewTransform(void)
  192. { 
  193.   switch (MoveMode) {
  194.     case FLYING:
  195.       FlyLookFrom(Ex, Ey, Ez, EyeAz, EyeEl);
  196.       break;
  197.     case POLAR:
  198.       PolarLookFrom(EyeDist, EyeEl, EyeAz);
  199.       break;
  200.     }
  201. }
  202.  
  203.   /*
  204.    * keep them vertical; I think this makes a lot of things easier, 
  205.    * but maybe it wouldn't be too hard to adapt things to let you go
  206.    * upside down
  207.    */
  208. int ConstrainEl(void)
  209. {
  210.   if (EyeEl <= -90) {
  211.     EyeEl = -89.99;
  212.     return 1;
  213.   } else if (EyeEl >= 90) {
  214.     EyeEl = 89.99;
  215.     return 1;
  216.   }
  217.   return 0;
  218. }
  219.  
  220.  /*
  221.   * Idle Function - moves eyeposition
  222.   */
  223. void agvMove(void)
  224. {
  225.  
  226.   switch (MoveMode)  {
  227.     case FLYING:
  228.       Ex += EyeMove*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  229.       Ey += EyeMove*sin(TORAD(EyeEl));
  230.       Ez -= EyeMove*cos(TORAD(EyeAz))*cos(TORAD(EyeEl));
  231.       break;
  232.  
  233.     case POLAR:
  234.       EyeEl += ElSpin;
  235.       EyeAz += AzSpin;
  236.       if (ConstrainEl()) {  /* weird spin thing to make things look     */
  237.         ElSpin = -ElSpin;      /* look better when you are kept from going */
  238.                                /* upside down while spinning - Isn't great */
  239.         if (fabs(ElSpin) > fabs(AzSpin))
  240.           AzSpin = fabs(ElSpin) * ((AzSpin > 0) ? 1 : -1);
  241.       }
  242.       break;
  243.     }
  244.  
  245.   if (AdjustingAzEl) {
  246.     dAz *= SLOW_DAZ;
  247.     dEl *= SLOW_DEL;
  248.   }
  249.  
  250.   if (AllowIdle) {
  251.     glutSetWindow(RedisplayWindow);
  252.     glutPostRedisplay();
  253.   }
  254. }
  255.  
  256.  
  257.   /*
  258.    * Don't install agvMove as idle unless we will be updating the view
  259.    * and we've been given a RedisplayWindow
  260.    */
  261. void MoveOn(int v)
  262. {
  263.   if (v && ((MoveMode == FLYING && EyeMove != 0) ||
  264.              (MoveMode == POLAR &&
  265.              (AzSpin != 0 || ElSpin != 0 || AdjustingAzEl)))) {
  266.     agvMoving = 1;
  267.     if (AllowIdle)
  268.       glutIdleFunc(agvMove);
  269.   } else {
  270.     agvMoving = 0;
  271.     if (AllowIdle)
  272.       glutIdleFunc(NULL);
  273.   }
  274. }
  275.  
  276.   /*
  277.    * set new redisplay window.  If <= 0 it means we are not to install
  278.    * an idle function and will rely on whoever does install one to 
  279.    * put statement like "if (agvMoving) agvMove();" at end of it
  280.    */
  281. void agvSetAllowIdle(int allowidle)
  282. {
  283.   if ((AllowIdle = allowidle))
  284.     MoveOn(1);
  285. }
  286.  
  287.  
  288.   /*
  289.    * when moving to flying we stay in the same spot, moving to polar we
  290.    * reset since we have to be looking at the origin (though a pivot from
  291.    * current position to look at origin might be cooler)
  292.    */
  293. void agvSwitchMoveMode(int move)
  294. {
  295.   switch (move) {
  296.     case FLYING:
  297.       if (MoveMode == FLYING) return;
  298.       Ex    = -EyeDist*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  299.       Ey    =  EyeDist*sin(TORAD(EyeEl));
  300.       Ez    =  EyeDist*(cos(TORAD(EyeAz))*cos(TORAD(EyeEl)));
  301.       EyeAz =  EyeAz;
  302.       EyeEl = -EyeEl;
  303.       EyeMove = INIT_MOVE;
  304.       break;
  305.     case POLAR:
  306.       EyeDist = INIT_DIST;
  307.       EyeAz   = INIT_POLAR_AZ;
  308.       EyeEl   = INIT_POLAR_EL;
  309.       AzSpin  = INIT_AZ_SPIN;
  310.       ElSpin  = INIT_EL_SPIN;
  311.       break;
  312.     }
  313.   MoveMode = move;
  314.   MoveOn(1);
  315.   glutPostRedisplay();
  316. }
  317.  
  318. /***************************************************************/
  319. /*******************    MOUSE HANDLING   ***********************/
  320. /***************************************************************/
  321.  
  322. void agvHandleButton(int button, int state, int x, int y)
  323. {
  324.  if (state == GLUT_DOWN && downb == -1) {  
  325.     lastx = downx = x;
  326.     lasty = downy = y;
  327.     downb = button;    
  328.  
  329.     switch (button) {
  330.       case GLUT_LEFT_BUTTON:
  331.         lastEl = downEl = EyeEl;
  332.         lastAz = downAz = EyeAz;
  333.         AzSpin = ElSpin = dAz = dEl = 0;
  334.         AdjustingAzEl = 1;
  335.     MoveOn(1);
  336.         break;
  337.  
  338.       case GLUT_MIDDLE_BUTTON:
  339.         downDist = EyeDist;
  340.     downEx = Ex;
  341.     downEy = Ey;
  342.     downEz = Ez;
  343.     downEyeMove = EyeMove;
  344.     EyeMove = 0;
  345.     }
  346.  
  347.   } else if (state == GLUT_UP && button == downb) {
  348.  
  349.     downb = -1;
  350.  
  351.     switch (button) {
  352.       case GLUT_LEFT_BUTTON:
  353.         if (MoveMode != FLYING) {
  354.       AzSpin =  -dAz;
  355.       if (AzSpin < MIN_AZSPIN && AzSpin > -MIN_AZSPIN)
  356.         AzSpin = 0;    
  357.       ElSpin = -dEl;
  358.       if (ElSpin < MIN_ELSPIN && ElSpin > -MIN_ELSPIN)
  359.         ElSpin = 0; 
  360.     }
  361.         AdjustingAzEl = 0;
  362.         MoveOn(1);
  363.     break;
  364.  
  365.       case GLUT_MIDDLE_BUTTON:
  366.     EyeMove = downEyeMove;
  367.       }
  368.   }
  369. }
  370.  
  371.  /*
  372.   * change EyeEl and EyeAz and position when mouse is moved w/ button down
  373.   */
  374. void agvHandleMotion(int x, int y)
  375. {
  376.   int deltax = x - downx, deltay = y - downy;
  377.  
  378.   switch (downb) {
  379.     case GLUT_LEFT_BUTTON:
  380.       EyeEl  = downEl + EL_SENS * ((MoveMode == FLYING) ? -deltay : deltay);
  381.       ConstrainEl();
  382.       EyeAz  = downAz + AZ_SENS * deltax;
  383.       dAz    = PREV_DAZ*dAz + CUR_DAZ*(lastAz - EyeAz);
  384.       dEl    = PREV_DEL*dEl + CUR_DEL*(lastEl - EyeEl);
  385.       lastAz = EyeAz;
  386.       lastEl = EyeEl;
  387.       break;
  388.     case GLUT_MIDDLE_BUTTON:
  389.         EyeDist = downDist + DIST_SENS*deltay;
  390.         Ex = downEx - E_SENS*deltay*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  391.         Ey = downEy - E_SENS*deltay*sin(TORAD(EyeEl));
  392.         Ez = downEz + E_SENS*deltay*cos(TORAD(EyeAz))*cos(TORAD(EyeEl));
  393.       break;
  394.   }
  395.   glutPostRedisplay();
  396. }
  397.  
  398. /***************************************************************/
  399. /********************* KEYBOARD HANDLING ***********************/
  400. /***************************************************************/
  401.  
  402.   /*
  403.    * set EyeMove (current speed) for FLYING mode
  404.    */
  405. void SetMove(float newmove)
  406. {
  407.   if (newmove > MINMOVE) {
  408.     EyeMove = newmove;
  409.     MoveOn(1);
  410.   } else {
  411.     EyeMove = 0;
  412.     MoveOn(0);
  413.   }
  414. }
  415.  
  416.   /*
  417.    * 0->9 set speed, +/- adjust current speed  -- in FLYING mode
  418.    */
  419. /* ARGSUSED1 */
  420. void agvHandleKeys(unsigned char key, int x, int y)
  421. {
  422.   if (MoveMode != FLYING)
  423.     return;
  424.  
  425.   if (key >= '0' && key <= '9')
  426.     SetMove(SPEEDFUNCTION((key-'0')));
  427.   else
  428.     switch(key) {
  429.       case '+':  
  430.         if (EyeMove == 0)
  431.           SetMove(MINMOVE);
  432.          else
  433.       SetMove(EyeMove *= (1 + MOVEFRACTION));
  434.         break;
  435.       case '-':
  436.     SetMove(EyeMove *= (1 - MOVEFRACTION));
  437.         break;
  438.     }
  439. }
  440.  
  441. /***************************************************************/
  442. /*********************** VECTOR STUFF **************************/
  443. /***************************************************************/
  444.  
  445.   /* normalizes v */
  446. static void normalize(GLfloat v[3])
  447. {
  448.   GLfloat d = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  449.  
  450.   if (d == 0)
  451.     fprintf(stderr, "Zero length vector in normalize\n");
  452.   else
  453.     v[0] /= d; v[1] /= d; v[2] /= d;
  454. }
  455.  
  456.   /* calculates a normalized crossproduct to v1, v2 */
  457. static void ncrossprod(float v1[3], float v2[3], float cp[3])
  458. {
  459.   cp[0] = v1[1]*v2[2] - v1[2]*v2[1];
  460.   cp[1] = v1[2]*v2[0] - v1[0]*v2[2];
  461.   cp[2] = v1[0]*v2[1] - v1[1]*v2[0];
  462.   normalize(cp);
  463. }
  464.  
  465. /***************************************************************/
  466. /**************************** AXES *****************************/
  467. /***************************************************************/
  468.  
  469.  
  470.   /* draw axes -- was helpful to debug/design things */
  471. void agvMakeAxesList(int displaylistnum)
  472. {
  473.   int i,j;
  474.   GLfloat axes_ambuse[] =   { 0.5, 0.0, 0.0, 1.0 };
  475.   glNewList(displaylistnum, GL_COMPILE);
  476.   glPushAttrib(GL_LIGHTING_BIT);
  477.   glMatrixMode(GL_MODELVIEW);
  478.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, axes_ambuse);
  479.     glBegin(GL_LINES);
  480.       glVertex3f(15, 0, 0); glVertex3f(-15, 0, 0);
  481.       glVertex3f(0, 15, 0); glVertex3f(0, -15, 0);
  482.       glVertex3f(0, 0, 15); glVertex3f(0, 0, -15);
  483.     glEnd();
  484.     for (i = 0; i < 3; i++) {
  485.       glPushMatrix();
  486.         glTranslatef(-10*(i==0), -10*(i==1), -10*(i==2));
  487.         for (j = 0; j < 21; j++) {
  488.           glutSolidCube(0.1);
  489.           glTranslatef(i==0, i==1, i==2);
  490.     }
  491.       glPopMatrix();
  492.     }
  493.   glPopAttrib();
  494.   glEndList();  
  495. }
  496.  
  497.  
  498.